home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 July / macformat-026.iso / mac / Shareware City / Science / µSim 1.0 folder / Libs / UtilsCommon.c < prev    next >
Encoding:
Text File  |  1995-03-10  |  43.1 KB  |  1,684 lines  |  [TEXT/MMCC]
  1. /*
  2. Copyright © 1993,1994 by Fabrizio Oddone
  3. ••• ••• ••• ••• ••• ••• ••• ••• ••• •••
  4. This source code is distributed as freeware: you can copy, exchange, modify this
  5. code as you wish. You may include this code in any kind of application: freeware,
  6. shareware, or commercial, provided that full credits are given.
  7. You may not sell or distribute this code for profit.
  8. */
  9.  
  10. //#pragma load "MacDump"
  11.  
  12. #include    "Independents.h"
  13. #include    "MovableModal.h"
  14.  
  15. static void CommonCopyToClip(short id);
  16.  
  17. #if !(defined(powerc) || defined (__powerc)) || defined(FabSystem7orlater)
  18.  
  19. #if    !defined(FabNoSegmentDirectives)
  20. #pragma segment Main
  21. #endif
  22.  
  23. static AEEventHandlerUPP    gmyOAPP_UPP, gmyODOC_UPP, gmyPDOC_UPP, gmyQUIT_UPP;
  24.  
  25. #if defined(powerc) || defined (__powerc)
  26.  
  27. pascal StringPtr     PLstrcpy(StringPtr str1, ConstStr255Param str2)
  28. {
  29. BlockMoveData(str2, str1, StrLength(str2) + 1);
  30. return str1;
  31. }
  32.  
  33. pascal StringPtr     PLstrncpy(StringPtr str1, ConstStr255Param str2, short num)
  34. {
  35. BlockMoveData(str2, str1, 1 + MIN(StrLength(str2), num));
  36. return str1;
  37. }
  38.  
  39. pascal StringPtr    PLstrcat(StringPtr str1, ConstStr255Param str2)
  40. {
  41. BlockMoveData(str2 + 1, str1 + StrLength(str1) + 1, StrLength(str2));
  42. StrLength(str1) += StrLength(str2);
  43. return str1;
  44. }
  45.  
  46. pascal StringPtr    PLstrncat(StringPtr str1, ConstStr255Param str2, short num)
  47. {
  48. BlockMoveData(str2 + 1, str1 + StrLength(str1) + 1, MIN(num, StrLength(str2)));
  49. StrLength(str1) += StrLength(str2);
  50. return str1;
  51. }
  52.  
  53. void MyZeroBuffer(long *p, long s)
  54. {
  55. for ( ; s-- >= 0; *p++ = 0L);
  56. }
  57.  
  58. void MyFillBuffer(long *p, long s, long filler)
  59. {
  60. for ( ; s-- >= 0; *p++ = filler);
  61. }
  62.  
  63. long mySwap(long s)
  64. {
  65. long    t;
  66.  
  67. t = s >> 16;
  68. *(short *)&t = (short) s;
  69. return t;
  70. }
  71.  
  72. #endif
  73.  
  74. /* AddSTRRes2Doc: adds the standard 'STR ' resource
  75. to a newly saved document */
  76.  
  77. OSErr AddSTRRes2Doc(FSSpec *theDoc, OSType myFcrea, OSType myFtype, short STRid, ScriptCode lScript)
  78. {
  79. register Handle    msgString;
  80. register short    fRefn;
  81. register OSErr    err;
  82.  
  83. DetachResource(msgString = (Handle)GetString(STRid));
  84. FSpCreateResFileCompat(theDoc, myFcrea, myFtype, lScript);
  85. if ((err = ResError()) == noErr)
  86.     if ((fRefn = FSpOpenResFileCompat(theDoc, fsRdWrPerm)) == -1)
  87.         err = ResError();
  88.     else {
  89.         AddResource(msgString, 'STR ', STRid, "\p");
  90.         if ((err = ResError()) == noErr) {
  91.             SetResAttrs(msgString, GetResAttrs(msgString) | resPurgeable);
  92.             err = ResError();
  93.             }
  94.         else
  95.             DisposeHandle(msgString);
  96.         CloseResFile(fRefn);
  97.         }
  98. return err;
  99. }
  100.  
  101. /* AddSTRHand2Doc: adds the standard 'STR ' resource
  102. to a newly saved document */
  103.  
  104. OSErr AddSTRHand2Doc(FSSpec *theDoc, OSType myFcrea, OSType myFtype, StringHandle msgString, ScriptCode lScript)
  105. {
  106. register short    fRefn;
  107. register OSErr    err;
  108.  
  109. FSpCreateResFileCompat(theDoc, myFcrea, myFtype, lScript);
  110. if ((err = ResError()) == noErr)
  111.     if ((fRefn = FSpOpenResFileCompat(theDoc, fsRdWrPerm)) == -1)
  112.         err = ResError();
  113.     else {
  114.         AddResource((Handle)msgString, 'STR ', kSTR_ApplicationName, "\p");
  115.         if ((err = ResError()) == noErr) {
  116.             SetResAttrs((Handle)msgString, GetResAttrs((Handle)msgString) | resPurgeable);
  117.             err = ResError();
  118.             }
  119.         else
  120.             DisposeHandle((Handle)msgString);
  121.         CloseResFile(fRefn);
  122.         }
  123. return err;
  124. }
  125.  
  126. OSErr AddRes2Doc(FSSpec *theDoc, Handle thisHandle, ResType rType, short rID)
  127. {
  128. register Handle    existHandle;
  129. register short    fRefn;
  130. register OSErr    err;
  131.  
  132. if ((fRefn = FSpOpenResFileCompat(theDoc, fsRdWrPerm)) == -1)
  133.     err = ResError();
  134. else {
  135. //    if (noErr == (err = HandToHand(&thisHandle)))
  136.     SetResLoad(false);
  137.     existHandle = Get1Resource(rType, rID);
  138.     SetResLoad(true);
  139.     if (existHandle) {
  140.         RemoveResource(existHandle);
  141.         DisposeHandle(existHandle);
  142.         }
  143.     AddResource(thisHandle, rType, rID, "\p");
  144.     if ((err = ResError()) == noErr) {
  145.         SetResAttrs(thisHandle, GetResAttrs(thisHandle) | resPurgeable);
  146.         err = ResError();
  147.         }
  148.     CloseResFile(fRefn);
  149.     }
  150. return err;
  151. }
  152.  
  153. /* SendmyAE: we send an Apple Event with the specified ID to ourselves */
  154.  
  155. void SendmyAE(AEEventClass myclass, AEEventID myAEvtID, AEIdleProcPtr IdleFunct, AESendMode theMode)
  156. {
  157. AEIdleUPP    IdleFunctUPP = NewAEIdleProc(IdleFunct);
  158. AppleEvent    myAEvent;
  159. AppleEvent    myAEReply;
  160. AEAddressDesc    targetAddress;
  161. ProcessSerialNumber myPSN = { 0, kCurrentProcess };
  162. register OSErr    err;
  163.  
  164. if ((err = AECreateDesc(typeProcessSerialNumber, (Ptr)&myPSN, sizeof(ProcessSerialNumber),
  165.     &targetAddress)) == noErr) {
  166.     if ((err = AECreateAppleEvent(myclass, myAEvtID, &targetAddress,
  167.         kAutoGenerateReturnID, kAnyTransactionID, &myAEvent)) == noErr) {
  168.         err = AESend(&myAEvent, &myAEReply, theMode,
  169.             kAENormalPriority, kNoTimeOut, IdleFunctUPP, 0L);
  170.         (void)AEDisposeDesc(&myAEvent);
  171.         }
  172.     (void)AEDisposeDesc(&targetAddress);
  173.     }
  174. if (IdleFunctUPP)
  175.     DisposeRoutineDescriptor(IdleFunctUPP);
  176. }
  177.  
  178. /* SendmyAEPShort: we send an Apple Event with the specified ID to ourselves */
  179.  
  180. void SendmyAEPShort(AEEventClass myclass, AEEventID myAEvtID, AEIdleProcPtr IdleFunct, AESendMode theMode, short theAlert)
  181. {
  182. AEIdleUPP    IdleFunctUPP = NewAEIdleProc(IdleFunct);
  183. AppleEvent    myAEvent;
  184. AppleEvent    myAEReply;
  185. AEAddressDesc    targetAddress;
  186. ProcessSerialNumber myPSN = { 0, kCurrentProcess };
  187. register OSErr    err;
  188.  
  189. if ((err = AECreateDesc(typeProcessSerialNumber, (Ptr)&myPSN, sizeof(ProcessSerialNumber),
  190.     &targetAddress)) == noErr) {
  191.     if ((err = AECreateAppleEvent(myclass, myAEvtID, &targetAddress,
  192.         kAutoGenerateReturnID, kAnyTransactionID, &myAEvent)) == noErr) {
  193.  
  194.         if ((err = AEPutParamPtr(&myAEvent, keyDirectObject, typeShortInteger, (Ptr)&theAlert, sizeof(theAlert))) == noErr)
  195.             err = AESend(&myAEvent, &myAEReply, theMode,
  196.                 kAENormalPriority, kNoTimeOut, IdleFunctUPP, 0L);
  197.         (void)AEDisposeDesc(&myAEvent);
  198.         }
  199.     (void)AEDisposeDesc(&targetAddress);
  200.     }
  201. if (IdleFunctUPP)
  202.     DisposeRoutineDescriptor(IdleFunctUPP);
  203. }
  204.  
  205. /* ZoomRectToRect: draws zooming gray rectangles from startingRect to endingRect
  206. in the current port; numofDivs is the density of rectangles in the interval */
  207.  
  208. void ZoomRectToRect(RectPtr startingRect, RectPtr endingRect, short numofDivs)
  209. {
  210. PenState    curPen;
  211. Rect    trailingRect = { 0, 0, 0, 0 };
  212. Rect    tempRect;
  213. Handle    rectStorH;
  214. short    mtop, mleft, mbottom, mright;
  215. register long    ttopleft, tbotright;
  216. register short *spntr;
  217. register long *lpntr;
  218. register short    i, j, tsh;
  219.  
  220. if (numofDivs < (CHAR_BIT * sizeof(short))) {
  221.     if (rectStorH = NewHandleGeneral(numofDivs * sizeof(Rect))) {
  222.         GetPenState(&curPen);
  223.         PenPat(&qd.gray);
  224.         PenMode(patXor);
  225.         mtop = endingRect->top - startingRect->top;
  226.         mleft = endingRect->left - startingRect->left;
  227.         mbottom = endingRect->bottom - startingRect->bottom;
  228.         mright = endingRect->right - startingRect->right;
  229.         spntr = (short *)*rectStorH;
  230.         for (i = 1; i <= numofDivs; i++) {
  231.             *spntr++ = mtop >>= 1;
  232.             *spntr++ = mleft >>= 1;
  233.             *spntr++ = mbottom >>= 1;
  234.             *spntr++ = mright >>= 1;
  235.             }
  236.         HLock(rectStorH);
  237.         for (i = 1; i < (1 << numofDivs); i++) {
  238.             ttopleft = *(long *)startingRect;
  239.             tbotright = ((long *)startingRect)[1];
  240.             lpntr = (long *)*rectStorH;
  241.             tsh = i << ((CHAR_BIT * sizeof(short)) - numofDivs);
  242.             for (j = 1; j <= numofDivs; j++) {
  243.                 if (tsh < 0) {
  244.                     ttopleft += *lpntr++;
  245.                     tbotright += *lpntr++;
  246.                     }
  247.                 else
  248.                     lpntr += 2;
  249.                 tsh <<= 1;
  250.                 }
  251.             
  252.             *(long *)&tempRect = ttopleft;
  253.             ((long *)&tempRect)[1] = tbotright;
  254.             FrameRect(&tempRect);
  255.             FrameRect(&trailingRect);
  256.             trailingRect = tempRect;
  257.             }
  258.         FrameRect(&tempRect);
  259.         DisposeHandle(rectStorH);
  260.         SetPenState(&curPen);
  261.         }
  262.     }
  263. }
  264.  
  265. void ZoomRectToRectAutoGrafPort(RectPtr startingRect, RectPtr endingRect, short numofDivs)
  266. {
  267. GrafPtr        savePort;
  268. GrafPort    ZoomPort;
  269.  
  270. GetPort(&savePort);
  271. OpenPort(&ZoomPort);
  272. ZoomRectToRect(startingRect, endingRect, numofDivs);
  273. ClosePort(&ZoomPort);
  274. SetPort(savePort);
  275. }
  276.  
  277. /* NewHandleGeneral: makes a new handle in main or temporary memory, arguably
  278. in the more suitable heap zone */
  279.  
  280. Handle NewHandleGeneral(Size blockSize)
  281. {
  282. register Handle    myH;
  283. OSErr    err;
  284.  
  285. if (TempFreeMem() > FreeMem()) {
  286.     if ((myH = TempNewHandle(blockSize, &err)) == nil) {
  287.         ReserveMem(blockSize);
  288.         myH = NewHandle(blockSize);
  289.         }
  290.     }
  291. else {
  292.     ReserveMem(blockSize);
  293.     if ((myH = NewHandle(blockSize)) == nil)
  294.         myH = TempNewHandle(blockSize, &err);
  295.     }
  296. return(myH);
  297. }
  298.  
  299. /* Get1ResGeneral: like Get1Resource, but loads in main or temporary memory */
  300.  
  301. Handle Get1ResGeneral(ResType theType,short theID)
  302. {
  303. register Handle    emptyH, destH;
  304. register Size    myResSize;
  305.  
  306. SetResLoad(false);
  307. emptyH = Get1Resource(theType, theID);
  308. SetResLoad(true);
  309. destH = NewHandleGeneral(myResSize = GetResourceSizeOnDisk(emptyH));
  310. if (destH) {
  311.     HLock(destH);
  312.     ReadPartialResource(emptyH, 0L, *destH, myResSize);
  313.     HUnlock(destH);
  314.     }
  315. ReleaseResource(emptyH);
  316. return(destH);
  317. }
  318.  
  319. OSType FindFinderAtEaseProcess(ProcessSerialNumber *theProcess)
  320. {
  321. ProcessInfoRec infoRec;
  322. ProcessSerialNumber process = {0L, kNoProcess};
  323. register OSType    retVal = '????';
  324.  
  325. infoRec.processInfoLength = sizeof(ProcessInfoRec);
  326. infoRec.processName = nil;
  327. infoRec.processAppSpec = nil;
  328.  
  329. while (GetNextProcess(&process) == noErr) {
  330.     if (noErr == (GetProcessInformation(&process, &infoRec))) {
  331.         if ((infoRec.processType == (unsigned long)'FNDR') &&
  332.             ((infoRec.processSignature == 'MACS') || (infoRec.processSignature == 'mfdr'))) {
  333.             
  334.             retVal = infoRec.processSignature;
  335.             *theProcess = process;
  336.             break;
  337.             }
  338.         }
  339.     }
  340. return retVal;
  341. }
  342.  
  343. OSType FindFinderProcess(void)
  344. {
  345. ProcessInfoRec infoRec;
  346. ProcessSerialNumber process = {0, kNoProcess};
  347. register OSType    retVal = '????';
  348.  
  349. infoRec.processInfoLength = sizeof(ProcessInfoRec);
  350. infoRec.processName = nil;
  351. infoRec.processAppSpec = nil;
  352.  
  353. while (GetNextProcess(&process) == noErr) {
  354.     if (noErr == (GetProcessInformation(&process, &infoRec))) {
  355.         if ((infoRec.processType == (unsigned long)'FNDR') &&
  356.             (infoRec.processSignature == 'MACS')) {
  357.             
  358.             retVal = infoRec.processSignature;
  359.             break;
  360.             }
  361.         }
  362.     }
  363. return retVal;
  364. }
  365.  
  366. /* SendShutdownToFinder: we tell the Finder (or At Ease) to Shutdown (!) */
  367.  
  368. OSErr SendShutdownToFinder(AEIdleProcPtr myIdleFunct, Boolean wantShutDown)
  369. {
  370. AEIdleUPP    myIdleFunctUPP = NewAEIdleProc(myIdleFunct);
  371. AppleEvent    myAEvent;
  372. AppleEvent    myAEReply;
  373. ProcessSerialNumber    process;
  374. AEAddressDesc    targetAddress;
  375. OSType    WantedCreator;
  376. register OSErr    err = errAEDescNotFound;
  377.  
  378. WantedCreator = FindFinderAtEaseProcess(&process);
  379. if ('????' != WantedCreator)
  380.     if ((err = AECreateDesc(typeApplSignature, (Ptr)&WantedCreator, sizeof(OSType),
  381.         &targetAddress)) == noErr) {
  382.         if ((err = AECreateAppleEvent(kAEFinderEvents, wantShutDown ? kAEShutDown : kAERestart , &targetAddress,
  383.             kAutoGenerateReturnID, kAnyTransactionID, &myAEvent)) == noErr) {
  384.             err = AESend(&myAEvent, &myAEReply, kAENoReply | kAEAlwaysInteract,
  385.                 kAENormalPriority, kNoTimeOut, myIdleFunctUPP, nil);
  386.             (void)AEDisposeDesc(&myAEvent);
  387.             if (err == noErr)
  388.                 (void)SetFrontProcess(&process);
  389.             }
  390.         (void)AEDisposeDesc(&targetAddress);
  391.         }
  392. if (myIdleFunctUPP)
  393.     DisposeRoutineDescriptor(myIdleFunctUPP);
  394. return err;
  395. }
  396.  
  397. short StopAlert_UPP(short alertID, ModalFilterProcPtr filterProc)
  398. {
  399. ModalFilterUPP    filterProcUPP = nil;
  400. register short    butHit;
  401.  
  402. if (filterProc)
  403.     filterProcUPP = NewModalFilterProc(filterProc);
  404. InitCursor();
  405. butHit = StopAlert(alertID, filterProcUPP);
  406. if (filterProcUPP)
  407.     DisposeRoutineDescriptor(filterProcUPP);
  408. return butHit;
  409. }
  410.  
  411. short StopAlert_AE(short alertID, ModalFilterProcPtr filterProc, AEIdleProcPtr IdleFunct)
  412. {
  413.  
  414. SendmyAE(kCreat, kAEAlert, IdleFunct, kAENoReply | kAEAlwaysInteract);
  415. return StopAlert_UPP(alertID, filterProc);
  416. }
  417.  
  418. short CautionAlert_UPP(short alertID, ModalFilterProcPtr filterProc)
  419. {
  420. ModalFilterUPP    filterProcUPP = nil;
  421. register short    butHit;
  422.  
  423. if (filterProc)
  424.     filterProcUPP = NewModalFilterProc(filterProc);
  425. InitCursor();
  426. butHit = CautionAlert(alertID, filterProcUPP);
  427. if (filterProcUPP)
  428.     DisposeRoutineDescriptor(filterProcUPP);
  429. return butHit;
  430. }
  431.  
  432. short CautionAlert_AE(short alertID, ModalFilterProcPtr filterProc, AEIdleProcPtr IdleFunct)
  433. {
  434.  
  435. SendmyAE(kCreat, kAEAlert, IdleFunct, kAENoReply | kAEAlwaysInteract);
  436. return CautionAlert_UPP(alertID, filterProc);
  437. }
  438.  
  439. short NoteAlert_UPP(short alertID, ModalFilterProcPtr filterProc)
  440. {
  441. ModalFilterUPP    filterProcUPP = nil;
  442. register short    butHit;
  443.  
  444. if (filterProc)
  445.     filterProcUPP = NewModalFilterProc(filterProc);
  446. InitCursor();
  447. butHit = NoteAlert(alertID, filterProcUPP);
  448. if (filterProcUPP)
  449.     DisposeRoutineDescriptor(filterProcUPP);
  450. return butHit;
  451. }
  452.  
  453. short NoteAlert_AE(short alertID, ModalFilterProcPtr filterProc, AEIdleProcPtr IdleFunct)
  454. {
  455.  
  456. SendmyAE(kCreat, kAEAlert, IdleFunct, kAENoReply | kAEAlwaysInteract);
  457. return NoteAlert_UPP(alertID, filterProc);
  458. }
  459.  
  460. short Alert_UPP(short alertID, ModalFilterProcPtr filterProc)
  461. {
  462. ModalFilterUPP    filterProcUPP = nil;
  463. register short    butHit;
  464.  
  465. if (filterProc)
  466.     filterProcUPP = NewModalFilterProc(filterProc);
  467. InitCursor();
  468. butHit = Alert(alertID, filterProcUPP);
  469. if (filterProcUPP)
  470.     DisposeRoutineDescriptor(filterProcUPP);
  471. return butHit;
  472. }
  473.  
  474. short Alert_AE(short alertID, ModalFilterProcPtr filterProc, AEIdleProcPtr IdleFunct)
  475. {
  476.  
  477. SendmyAE(kCreat, kAEAlert, IdleFunct, kAENoReply | kAEAlwaysInteract);
  478. return Alert_UPP(alertID, filterProc);
  479. }
  480.  
  481. /* my Dialog box manager */
  482.  
  483. void FlashButton(DialogPtr dlg, short item)
  484. {
  485. Rect    txtBox;
  486. ControlHandle    itH;
  487. long    dummy;
  488. short    typ;
  489.  
  490. GetDialogItem(dlg, item, &typ, (Handle *)&itH, &txtBox);
  491. HiliteControl(itH, 1);
  492. Delay(4L, &dummy);
  493. HiliteControl(itH, 0);
  494. }
  495.  
  496. static void FrameRoundBW(const RectPtr theRect, ConstPatternParam bpat, short ovalP);
  497.  
  498. enum {
  499. kIsColorPort = 0xC000,
  500. kButtonFrameSize = 3,    /* button frame's pen size */
  501. kButtonFrameInset = -4    /* inset rectangle adjustment around button */
  502. };
  503.  
  504. void OutlineButton(DialogPtr oftheDialog, short myItem)
  505. {
  506. RGBColor    foreCol, backCol, savedForeCol;
  507. PenState    curPen;
  508. PatPtr    thePat;
  509. GrafPtr    savePort;
  510. Rect    txtBox;
  511. Handle    itH;
  512. short    typ;
  513.  
  514. GetDialogItem(oftheDialog, myItem, &typ, &itH, &txtBox);
  515. GetPort(&savePort);
  516. SetPort(oftheDialog);
  517.  
  518. InsetRect(&txtBox, kButtonFrameInset, kButtonFrameInset);
  519. typ = ((txtBox.bottom - txtBox.top) >> 1) + 2;
  520.  
  521. thePat = (*(ControlHandle)itH)->contrlHilite == 0 ? &qd.black : &qd.gray;
  522.  
  523. GetPenState(&curPen);
  524. PenNormal();
  525. PenSize(kButtonFrameSize, kButtonFrameSize);
  526. if ((((CGrafPtr)(*(ControlHandle)itH)->contrlOwner)->portVersion & kIsColorPort) == kIsColorPort) {
  527.     if ((*(ControlHandle)itH)->contrlHilite) {
  528.         GetForeColor(&foreCol);
  529.         savedForeCol = foreCol;
  530.         GetBackColor(&backCol);
  531.         if (GetGray(GetGDevice(), &backCol, &foreCol)) {
  532.             RGBForeColor(&foreCol);
  533.             FrameRoundRect(&txtBox, typ, typ);
  534.             RGBForeColor(&savedForeCol);
  535.             }
  536.         else
  537.             FrameRoundBW(&txtBox, thePat, typ);
  538.         }
  539.     else
  540.         FrameRoundRect(&txtBox, typ, typ);
  541.     }
  542. else {
  543.     FrameRoundBW(&txtBox, thePat, typ);
  544.     }
  545.  
  546. SetPenState(&curPen);
  547. SetPort(savePort);
  548. }
  549.  
  550. void FrameRoundBW(const RectPtr theRect, ConstPatternParam bpat, short ovalP)
  551. {
  552. PenPat(bpat);
  553. FrameRoundRect(theRect, ovalP, ovalP);
  554. }
  555.  
  556. short HandleDialog(ModalFilterProcPtr filterProc,
  557.                     dialogItemsPtr things,
  558.                     void (*initProc)(DialogPtr),
  559.                     void (*userProc)(DialogPtr, Handle, short),
  560.                     short resId)
  561. {
  562. ModalFilterUPP    filterProcUPP = NewModalFilterProc(filterProc);
  563. Rect    box;
  564. Handle    item;
  565. GrafPtr    port;
  566. register long    myRefCon;
  567. register DialogPtr    dPtr;
  568. register dialogItemsPtr    spanPtr;
  569. dialogItemsPtr    itemToBeActivated;
  570. short    type, theItemHit = memFullErr;
  571. short    theGroup, lastItemClosingDialog = cancel;
  572. register short    theType, iNum;
  573. register Boolean    editTextExists = false;
  574. Boolean    dialoging;
  575. #if !defined(FabSystem7orlater)
  576. long    Gresp;
  577. Boolean    dialogManager7Present = false;
  578. #endif
  579.  
  580. InitCursor();
  581. dPtr = GetNewDialog(resId, nil, (DialogPtr)-1L);
  582. if (dPtr) {
  583.     GetPort(&port);
  584.     SetPort(dPtr);
  585.  
  586. #if !defined(FabSystem7orlater)
  587.     if (Gestalt(gestaltDITLExtAttr, &Gresp) == noErr)
  588.         if (Gresp & (1L << gestaltDITLExtPresent))
  589.             dialogManager7Present = true;
  590. #endif
  591.  
  592. #pragma mark Setup
  593.     
  594.     spanPtr = things;
  595.     while (iNum = spanPtr->itemNumber) {
  596.         myRefCon = spanPtr->refCon;
  597.         GetDialogItem(dPtr, iNum, &type, &item, &box);
  598.         theType = type & itemDisable ? type - itemDisable : type;
  599.         switch(theType) {
  600.             case ctrlItem+btnCtrl:
  601. #if !defined(FabSystem7orlater)
  602.                 if (dialogManager7Present)
  603. #endif
  604.                     {
  605.                     if (myRefCon == 1L)
  606.                         (void) SetDialogDefaultItem(dPtr, iNum);
  607.                     else if (myRefCon == 2L)
  608.                         lastItemClosingDialog = iNum;
  609.                     if (iNum == cancel)
  610.                         (void) SetDialogCancelItem(dPtr, iNum);
  611.                     }
  612.                 break;
  613.             case ctrlItem+chkCtrl:
  614.             case ctrlItem+radCtrl:
  615.                 if (myRefCon > 0) {
  616.                     SetControlValue((ControlHandle)item, 1);
  617.                     if (userProc)
  618.                         userProc(dPtr, item, iNum);
  619.                     }
  620. /*                else if (myRefCon == 0) {
  621.                     if (userProc)
  622.                         userProc(dPtr, item, iNum);
  623.                     }*/
  624.                 else if (myRefCon < 0)
  625.                     HiliteControl((ControlHandle)item, 255);
  626.                 break;
  627.             case ctrlItem+resCtrl:
  628.                 if (myRefCon)
  629.                     SetControlValue((ControlHandle)item, myRefCon);
  630.                 break;
  631.             case statText:
  632.                 if (myRefCon)
  633.                     SetDialogItemText(item, (StringPtr)myRefCon);
  634.                 break;
  635.             case editText:
  636.                 SetDialogItemText(item, (StringPtr)myRefCon);
  637.                 if(editTextExists == false) {
  638.                     SelectDialogItemText(dPtr, iNum, 0, SHRT_MAX);
  639.                     editTextExists = true;
  640.                     }
  641.                 break;
  642.     //        case iconItem:
  643.     //            break;
  644.     //        case picItem:
  645.     //            break;
  646.             case userItem:
  647.                 SetDialogItem(dPtr, iNum, type, (Handle)myRefCon, &box);
  648.                 break;
  649.             }
  650.         spanPtr++;
  651.         }
  652. #if !defined(FabSystem7orlater)
  653.     if (dialogManager7Present)
  654. #endif
  655.         (void) SetDialogTracksCursor(dPtr, editTextExists);
  656.     if (initProc)
  657.         initProc(dPtr);
  658.     ShowWindow(dPtr);
  659.     
  660. #pragma mark Event Loop
  661.     
  662.     dialoging = true;
  663.     do {
  664.         ModalDialog(filterProcUPP, &theItemHit);
  665.         if (theItemHit) {
  666.             GetDialogItem(dPtr, theItemHit, &type, &item, &box);
  667.             switch (type) {
  668.                 case ctrlItem+btnCtrl:
  669.                     if ((theItemHit >= ok) && (theItemHit <= lastItemClosingDialog))
  670.                         dialoging = false;
  671.                     else if (userProc)
  672.                         userProc(dPtr, item, theItemHit);
  673.                     break;
  674.                 case ctrlItem+chkCtrl:
  675.                     SetControlValue((ControlHandle)item, 1 - GetControlValue((ControlHandle)item));
  676.                     if (userProc)
  677.                         userProc(dPtr, item, theItemHit);
  678.                     break;
  679.                 case ctrlItem+radCtrl:
  680.                     if (GetControlValue((ControlHandle)item) == 0) {
  681.                         SetControlValue((ControlHandle)item, 1);
  682.                         for (spanPtr = things; (++spanPtr)->itemNumber != theItemHit; )
  683.                             ;
  684.                         itemToBeActivated = spanPtr;
  685.                         for (theGroup = spanPtr->group; (--spanPtr)->group == theGroup; )
  686.                             ;
  687.                         while ((++spanPtr)->refCon <= 0L)
  688.                             ;
  689.                         GetDialogItem(dPtr, spanPtr->itemNumber, &type, &item, &box);
  690.                         SetControlValue((ControlHandle)item, 0);
  691.                         spanPtr->refCon = 0L;
  692.                         itemToBeActivated->refCon = 1L;
  693.                         if (userProc)
  694.                             userProc(dPtr, item, theItemHit);
  695.                         }
  696.                     break;
  697.                 case ctrlItem+resCtrl:
  698.                 case editText:
  699.                     if (userProc)
  700.                         userProc(dPtr, item, theItemHit);
  701.                     break;
  702.                 }
  703.             }
  704.         }
  705.     while (dialoging);
  706.     
  707. #pragma mark Return Settings
  708.     
  709.     if (theItemHit == ok) {
  710.         spanPtr = things;
  711.         while (iNum = spanPtr->itemNumber) {
  712.             GetDialogItem(dPtr, iNum, &type, &item, &box);
  713.             theType = type & itemDisable ? type - itemDisable : type;
  714.             switch(theType) {
  715.                 case ctrlItem+chkCtrl:
  716.                 case ctrlItem+resCtrl:
  717.                     spanPtr->refCon = GetControlValue((ControlHandle)item);
  718.                     break;
  719.                 case editText:
  720.                     GetDialogItemText(item, (StringPtr)spanPtr->refCon);
  721.                     break;
  722.         //        case iconItem:
  723.         //            break;
  724.         //        case picItem:
  725.         //            break;
  726.         //        case userItem:
  727.         //            break;
  728.                 }
  729.             spanPtr++;
  730.             }
  731.         }
  732.     DisposeDialog(dPtr);
  733.     SetPort(port);
  734.     }
  735. else
  736.     SysBeep(30);
  737. if (filterProcUPP)
  738.     DisposeRoutineDescriptor(filterProcUPP);
  739. InitCursor();
  740. return theItemHit;
  741. }
  742.  
  743. /* About box manager */
  744.  
  745. #if    !defined(FabNoSegmentDirectives)
  746. #pragma segment About
  747. #endif
  748.  
  749. /* myAbout: the events directed against the about box are checked with
  750. EventAvail, so that we can discard the about box and process
  751. important events later in the main event loop */
  752.  
  753. void myAbout(void (*theIdleProc)(void),
  754.             UserItemUPP DrawQTPict,
  755.             void (*UpdateProc)(EventRecord *),
  756.             void (*ActivateProc)(EventRecord *)
  757.             )
  758. {
  759. EventRecord    evrec;
  760. DialogPtr    agh, dPtr;
  761. short    iHit;
  762. register Handle    splash;
  763. register Boolean    exit = false;
  764.  
  765. splash = OpenSplash(&agh, DrawQTPict);
  766. if (splash) {
  767.     ShowWindow(agh);
  768.     do {
  769.         SystemTask();
  770.         if (EventAvail(everyEvent, &evrec)) {
  771.             switch(evrec.what) {
  772.                 case mouseDown:
  773.                 case keyDown:
  774.                 case autoKey:
  775.                     exit = true;
  776.                     FlushEvents(mDownMask | mUpMask | keyDownMask | autoKeyMask, 0);
  777.                     break;
  778.                 case mouseUp:
  779.                     (void)GetNextEvent(mUpMask, &evrec);
  780.                     break;
  781.                 case updateEvt :
  782.                     (void)GetNextEvent(updateMask, &evrec);
  783.                     if ((DialogPtr)evrec.message == agh) {
  784.                         BeginUpdate(agh);
  785.                         UpdateDialog(agh, agh->visRgn);
  786.                         EndUpdate(agh);
  787.                         }
  788.                     else
  789.                         if (IsDialogEvent(&evrec))
  790.                             (void) DialogSelect(&evrec, &dPtr, &iHit);
  791.                         else
  792.                             UpdateProc(&evrec);
  793.                     break;
  794.                 case diskEvt :
  795.                 case osEvt :
  796.                 case kHighLevelEvent:
  797.                     exit = true;
  798.                     break;
  799.                 case activateEvt :
  800.                     (void)GetNextEvent(activMask, &evrec);
  801.                     if ((DialogPtr)evrec.message != agh) {
  802.                         if (IsDialogEvent(&evrec))
  803.                             (void) DialogSelect(&evrec, &dPtr, &iHit);
  804.                         else
  805.                             ActivateProc(&evrec);
  806.                         }
  807.                     break;
  808.                 case driverEvt :
  809.                     (void)GetNextEvent(driverMask, &evrec);
  810.                     break;
  811.                 }
  812.             }
  813.         else {
  814.             theIdleProc();
  815.             }
  816.         }
  817.     while (exit == false);
  818.     DisposeSplash(splash, agh);
  819.     }
  820. else
  821.     SysBeep(30);
  822. }
  823.  
  824. /* OpenSplash: puts up the about window */
  825.  
  826. Handle OpenSplash(DialogPtr *pass, UserItemUPP DrawQTPict)
  827. {
  828. enum {
  829. kDLOG_About = 256,
  830. kItemPICT = 1
  831. };
  832.  
  833. Str15    tempS = "\p";
  834. Rect    box;
  835. register DialogPtr    dPtr;
  836. register VersRecHndl    myvers;
  837. register Handle    hand;
  838. Handle    item;
  839. short    type;
  840.  
  841. hand = NewHandle(sizeof(DialogRecord));
  842. if (hand) {
  843.     HLockHi(hand);
  844.     myvers = (VersRecHndl)Get1Resource('vers', 1);
  845.     if (myvers) {
  846.         (void) PLstrncpy(tempS, (*myvers)->shortVersion, 15);
  847.         ReleaseResource((Handle)myvers);
  848.         }
  849.     else
  850.         tempS[0] = 0;
  851.     ParamText((ConstStr255Param)&tempS, nil, nil, nil);
  852.     *pass = dPtr = GetNewDialog(kDLOG_About, *hand, (DialogPtr)-1L);
  853.     if (dPtr) {
  854.         if (DrawQTPict) {
  855.             GetDialogItem(dPtr, kItemPICT, &type, &item, &box);
  856.             SetDialogItem(dPtr, kItemPICT, type, (Handle)DrawQTPict, &box);
  857.             }
  858.         }
  859.     else {
  860.         DisposeHandle(hand);
  861.         hand = nil;
  862.         }
  863.     }
  864. return(hand);
  865. }
  866.  
  867. /* DisposeSplash: gets rid of the about window */
  868.  
  869. void DisposeSplash(Handle dialog, DialogPtr pass)
  870. {
  871. CloseDialog(pass);
  872. DisposeHandle(dialog);
  873. }
  874.  
  875. void myMovableModalAbout(
  876.             Point *aboutTopLeft,
  877.             Point *creditsTopLeft,
  878.             void (*AdjustMenus)(void),
  879.             void (*Handle_My_Menu)(long),
  880.             void (*DomyKeyEvent)(EventRecord *),
  881.             void (*DoUpdate)(EventRecord *),
  882.             void (*DoActivate)(EventRecord *),
  883.             void (*DoHiLevEvent)(EventRecord *),
  884.             void (*DoOSEvent)(EventRecord *),
  885.             void (*DoIdle)(void),
  886.             unsigned long minSleep
  887.             )
  888. {
  889. Str15    tempS = "\p";
  890. dialogItems    things[] = {{ ok, 0, 1L },
  891.                         { cancel, 0, 0L },
  892.                         { 0, 0, 0L}
  893.                         };
  894. dialogItems    credits[] = {{ ok, 0, 1L },
  895.                         { 0, 0, 0L}
  896.                         };
  897. register VersRecHndl    myvers;
  898.  
  899. myvers = (VersRecHndl)Get1Resource('vers', 1);
  900. if (myvers) {
  901.     (void) PLstrncpy(tempS, (*myvers)->shortVersion, 15);
  902.     ReleaseResource((Handle)myvers);
  903.     }
  904. else
  905.     tempS[0] = 0;
  906. ParamText((ConstStr255Param)&tempS, nil, nil, nil);
  907. switch (HandleMovableModalDialog((dialogItemsPtr)&things, aboutTopLeft, nil, nil, nil, nil, nil,
  908.             AdjustMenus,
  909.             Handle_My_Menu,
  910.             DomyKeyEvent,
  911.             nil,
  912.             nil,
  913.             DoUpdate,
  914.             DoActivate,
  915.             DoHiLevEvent,
  916.             DoOSEvent,
  917.             DoIdle,
  918.             minSleep,
  919.             kDLOG_MovableAbout)) {
  920.     case ok:
  921.         break;
  922.     case cancel:
  923.         (void) HandleMovableModalDialog((dialogItemsPtr)&credits, creditsTopLeft, nil, nil, nil, nil, nil,
  924.             AdjustMenus,
  925.             Handle_My_Menu,
  926.             DomyKeyEvent,
  927.             nil,
  928.             nil,
  929.             DoUpdate,
  930.             DoActivate,
  931.             DoHiLevEvent,
  932.             DoOSEvent,
  933.             DoIdle,
  934.             minSleep,
  935.             kDLOG_MovableCredits);
  936.         break;
  937.     }
  938. }
  939.  
  940. #if    !defined(FabNoSegmentDirectives)
  941. #pragma segment Main
  942. #endif
  943.  
  944. #if defined(powerc) || defined (__powerc)
  945. SignedByte WantThisHandleSafe(Handle myH)
  946. {
  947. SignedByte    cMemTags;
  948.  
  949. cMemTags = HGetState(myH);
  950. HLockHi(myH);
  951. return cMemTags;
  952. }
  953.  
  954. #endif
  955.  
  956.  
  957. void CopyEMailAddrToClip(void)
  958. {
  959. CommonCopyToClip(kSTR_EMAILADDR);
  960. }
  961.  
  962. void CopyWWWURLToClip(void)
  963. {
  964. CommonCopyToClip(kSTR_WWWURL);
  965. }
  966.  
  967. void CommonCopyToClip(short id)
  968. {
  969. StringHandle    theStr;
  970.  
  971. if (theStr = GetString(id)) {
  972.     HLockHi((Handle)theStr);
  973.     if (noErr == ZeroScrap())
  974.         (void) PutScrap(**theStr, 'TEXT', *theStr + 1);
  975.     HUnlock((Handle)theStr);
  976.     (void)TEFromScrap();
  977.     }
  978. }
  979.  
  980. /* GetFontNumber: gets font number from font name */
  981.  
  982. Boolean GetFontNumber(ConstStr255Param fontName, short *fontNum)
  983. {
  984. Str255    systemFontName;
  985. register Boolean    retFlag;
  986.  
  987. GetFNum(fontName, fontNum);
  988. if ((retFlag = (*fontNum != 0)) == false) {
  989.     GetFontName(0, systemFontName);
  990.     retFlag = EqualString(fontName, systemFontName, false, false);
  991.     }
  992. return retFlag;
  993. }
  994.  
  995. /* this is taken from "Macintosh Programming Secrets"
  996. by Scott Knaster & Keith Rollin;
  997. optimization by Fabrizio Oddone */
  998.  
  999. Boolean CmdPeriod(EventRecord *theEvent)
  1000. {
  1001. #define    kModifiersMask    (0xFF00 & ~cmdKey)
  1002.  
  1003. Handle    hKCHR;
  1004. long    /*virtualKey, */keyInfo, state, keyCID;
  1005. short    keyCode;
  1006. Boolean    result = false;
  1007.  
  1008. if ((theEvent->what == keyDown) || (theEvent->what == autoKey)) {
  1009.     if (theEvent->modifiers & cmdKey) {
  1010. //        virtualKey = (theEvent->message >> 8) >> 8;
  1011.         keyCode = (theEvent->modifiers & kModifiersMask) | ((unsigned short)theEvent->message >> 8);
  1012.         state = 0;
  1013.         keyCID = GetScript(GetScriptManagerVariable(smKeyScript), smScriptKeys);
  1014.         hKCHR = GetResource('KCHR', keyCID);
  1015.         if (hKCHR) {
  1016.             keyInfo = KeyTranslate(*hKCHR, keyCode, &state);
  1017.             ReleaseResource(hKCHR);
  1018.             }
  1019.         else
  1020.             keyInfo = theEvent->message;
  1021.         
  1022.         if (((char)keyInfo == '.') || ((char)(keyInfo >> 16) == '.'))
  1023.             result = true;
  1024.         }
  1025.     }
  1026.  
  1027. return result;
  1028. }
  1029.  
  1030. /* other useful stuff to detect keypresses */
  1031.  
  1032. Boolean CmdPeriodOrEsc(EventRecord *theEvent)
  1033. {
  1034. return ((unsigned short)theEvent->message == kEscapeKey) || CmdPeriod(theEvent);
  1035. }
  1036.  
  1037. Boolean CmdPeriodOrEscConfirm(EventRecord *theEvent, short alertID, ModalFilterProcPtr filterProc)
  1038. {
  1039. register Boolean    retflag;
  1040.  
  1041. retflag = CmdPeriodOrEsc(theEvent);
  1042. if (retflag) {
  1043.     ModalFilterUPP    filterProcUPP = NewModalFilterProc(filterProc);
  1044.     
  1045.     InitCursor();
  1046.     retflag = CautionAlert(alertID, filterProcUPP) == cancel;
  1047.     if (filterProcUPP)
  1048.         DisposeRoutineDescriptor(filterProcUPP);
  1049.     }
  1050.  
  1051. return retflag;
  1052. }
  1053.  
  1054. #if    !defined(FabNoSegmentDirectives)
  1055. #pragma segment Registration
  1056. #endif
  1057.  
  1058. short gHowManyDollars;
  1059.  
  1060. /* RegistrationFilter: the filter filters entered characters, of course */
  1061.  
  1062. static void RegInitProc(DialogPtr myDPtr);
  1063. static Boolean RegistrationPreProcessKey(EventRecord *thEv, DialogPtr theD);
  1064. static void RegistrationPostProcessKey(EventRecord *thEv, DialogPtr theD);
  1065.  
  1066. Boolean RegistrationPreProcessKey(EventRecord *thEv, DialogPtr theD)
  1067. {
  1068. short    iHit;
  1069. unsigned char    keypressed;
  1070. Boolean    result = true;
  1071.  
  1072. keypressed = CHARFROMMESSAGE(thEv->message);
  1073. iHit = ((DialogPeek)theD)->editField + 1;
  1074. if (iHit == kItemQuantity) {
  1075.     if (keypressed >= 32 && ((thEv->modifiers & cmdKey) == 0)) {
  1076.         result = ( Munger((Handle)GetString(kSTR_RegDECALLOWED), 1L,
  1077.                         &keypressed, 1L, 0L, 0L) >= 0L );
  1078.         }
  1079.     }
  1080. return result;
  1081. }
  1082.  
  1083. void RegistrationPostProcessKey(EventRecord */*thEv*/, DialogPtr theD)
  1084. {
  1085.  
  1086. if ((((DialogPeek)theD)->editField + 1) == kItemQuantity)
  1087.     RegInitProc(theD);
  1088. }
  1089.  
  1090. void HandleRegistration(/*ModalFilterProcPtr filterProc,*/
  1091.                         Point *regDTopLeft,
  1092.                         long (*regCfgInfo)(Handle, long, StringPtr),
  1093.                         void (*AdjustMenus)(void),
  1094.                         void (*Handle_My_Menu)(long),
  1095.                         void (*DomyKeyEvent)(EventRecord *),
  1096.                         void (*DoUpdate)(EventRecord *),
  1097.                         void (*DoActivate)(EventRecord *),
  1098.                         void (*DoHiLevEvent)(EventRecord *),
  1099.                         void (*DoOSEvent)(EventRecord *),
  1100.                         void (*DoIdle)(void),
  1101.                         unsigned long minSleep,
  1102.                         short howManyDollars)
  1103. {
  1104. enum {
  1105. kNumStrings = 13,
  1106. kMyRegText = 256
  1107. };
  1108.  
  1109. StringPtr    regInfo[kNumStrings];
  1110. StdFileResult    theChosenFile;
  1111. ParamBlockRec    myPB;
  1112. EventRecord    dummyEv;
  1113. Str63    tempS = "\p";
  1114. long    gResp;
  1115. short    tmpFRefN;
  1116. const short    zero = 0x0130;
  1117. const short    dash = 0x012D;
  1118. const char    optspace = 'Δ';
  1119. Handle    regText;
  1120. VersRecHndl    myvers;
  1121. StringHandle    sh;
  1122. StringPtr    myAppName = nil;
  1123. long    lOffset;
  1124. short    i;
  1125. OSErr    err;
  1126. SignedByte    savedState;
  1127.  
  1128. dialogItems    things[] = {{ ok, 0, 0L },
  1129.                         { cancel, 0, 0L },
  1130.                         { kItemUserName, 0, 0L },
  1131.                         { kItemCompany, 0, 0L },
  1132.                         { kItemAddress, 0, 0L },
  1133.                         { kItemCity, 0, 0L },
  1134.                         { kItemState, 0, 0L },
  1135.                         { kItemZIP, 0, 0L },
  1136.                         { kItemCountry, 0, 0L },
  1137.                         { kItemE_mail, 0, 0L },
  1138.                         { kItemPhone, 0, 0L },
  1139.                         { kItemFAX, 0, 0L },
  1140.                         { kItemQuantity, 0, 0L },
  1141.                         { kItemCopyFrom, 0, 0L },
  1142.                         { kItemComments, 0, 0L },
  1143.                         { 0, 0, 0L}
  1144.                         };
  1145.  
  1146. lOffset = (long)NewPtrClear(kNumStrings * sizeof(Str255));
  1147. if (lOffset) {
  1148.     things[kItemUserName-1].refCon = lOffset;
  1149.     regInfo[0] = (StringPtr)lOffset;
  1150.     lOffset += (kNumStrings - 1) * sizeof(Str255);
  1151.     for (i = kItemComments - 1; i >= kItemCompany - 1; i--, lOffset -= sizeof(Str255)) {
  1152.         things[i].refCon = lOffset;
  1153.         regInfo[i-2] = (StringPtr)lOffset;
  1154.         }
  1155.     
  1156.     (void)PLstrcpy((StringPtr)things[kItemQuantity-1].refCon, "\p2");
  1157.     
  1158.     gHowManyDollars = howManyDollars;
  1159.     sh = GetString(kSTR_ApplicationName);
  1160.     if (sh) {
  1161.         savedState = WantThisHandleSafe((Handle)sh);
  1162.         myAppName = *sh;
  1163.         }
  1164.     
  1165.     ParamText(myAppName, (ConstStr255Param)&zero, (ConstStr255Param)&zero, nil);
  1166.     if (sh)
  1167.         HSetState((Handle)sh, savedState);
  1168.     do
  1169.         if (HandleMovableModalDialog((dialogItemsPtr)&things, regDTopLeft, nil, nil, RegInitProc, nil, nil,
  1170.                 AdjustMenus,
  1171.                 Handle_My_Menu,
  1172.                 DomyKeyEvent,
  1173.                 RegistrationPreProcessKey,
  1174.                 RegistrationPostProcessKey,
  1175.                 DoUpdate,
  1176.                 DoActivate,
  1177.                 DoHiLevEvent,
  1178.                 DoOSEvent,
  1179.                 DoIdle,
  1180.                 minSleep,
  1181.                 kDLOG_Register) == ok)
  1182.             do {
  1183.                 if ((err = AskForDestFile(&theChosenFile, nil, nil)) == dupFNErr) {
  1184.                     InitCursor();
  1185.                     (void)StopAlert(kALRT_REGCANNOTREPLACE, nil);
  1186.                     }
  1187.                 }
  1188.             while (err == dupFNErr);
  1189.         else
  1190.             err = dupFNErr;
  1191.     while (err == userCanceledErr);
  1192.     if (err == noErr) {
  1193.         regText = Get1Resource('TEXT', kMyRegText);
  1194.         if (regText) {
  1195.             DetachResource(regText);
  1196.             myvers = (VersRecHndl)Get1Resource('vers', 1);
  1197.             if (myvers) {
  1198.                 (void) PLstrcpy(tempS, (*myvers)->shortVersion);
  1199.                 ReleaseResource((Handle)myvers);
  1200.                 }
  1201.             lOffset = Munger(regText, 0L, &optspace, 1L, &tempS[1], tempS[0]);
  1202.             for (i = kItemUserName-3; i <= kItemFAX-3; i++)
  1203.                 lOffset = Munger(regText, lOffset, &optspace, 1L, ®Info[i][1], regInfo[i][0]);
  1204.             for (i = kItemCopyFrom-3; i <= kItemComments-3; i++)
  1205.                 lOffset = Munger(regText, lOffset, &optspace, 1L, ®Info[i][1], regInfo[i][0]);
  1206.             
  1207.             /* Mac model */
  1208.             if (Gestalt(gestaltMachineType, &gResp) == noErr) {
  1209.                 myAppName = GetPtrIndHString(GetResource('STR#', kMachineNameStrID), (unsigned short)(gResp - 1L));
  1210.                 lOffset = Munger(regText, lOffset, &optspace, 1L, &myAppName[1], myAppName[0]);
  1211.                 }
  1212.             else {
  1213.                 lOffset = Munger(regText, lOffset, &optspace, 1L, &((char *)&dash)[1], 1L);
  1214.                 }
  1215.             /* Sys version */
  1216.             if (Gestalt(gestaltSystemVersion, &gResp) == noErr) {
  1217.                 BCDVersNumToString(gResp, tempS);
  1218.                 }
  1219.             else {
  1220.                 *(short *)tempS = dash;
  1221.                 }
  1222.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1223.             /* addr mode info */
  1224.             if (Gestalt(gestaltAddressingModeAttr, &gResp) == noErr) {
  1225.                 MyNumToString(gResp, tempS);
  1226.                 }
  1227.             else {
  1228.                 *(short *)tempS = dash;
  1229.                 }
  1230.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1231.             /* A/UX info */
  1232.             if (Gestalt(gestaltAUXVersion, &gResp) == noErr) {
  1233.                 BCDVersNumToString(gResp, tempS);
  1234.                 }
  1235.             else {
  1236.                 *(short *)tempS = dash;
  1237.                 }
  1238.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1239.             /* Hardware info */
  1240.             if (Gestalt(gestaltHardwareAttr, &gResp) == noErr) {
  1241.                 MyNumToString(gResp, tempS);
  1242.                 }
  1243.             else {
  1244.                 *(short *)tempS = dash;
  1245.                 }
  1246.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1247.             /* VM info */
  1248.             if (Gestalt(gestaltVMAttr, &gResp) == noErr) {
  1249.                 MyNumToString(gResp, tempS);
  1250.                 }
  1251.             else {
  1252.                 *(short *)tempS = dash;
  1253.                 }
  1254.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1255.             /* Power Manager info */
  1256.             if (Gestalt(gestaltPowerMgrAttr, &gResp) == noErr) {
  1257.                 MyNumToString(gResp, tempS);
  1258.                 }
  1259.             else {
  1260.                 *(short *)tempS = dash;
  1261.                 }
  1262.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1263.             /* Processor type info */
  1264.             if (Gestalt(gestaltProcessorType, &gResp) == noErr) {
  1265.                 MyNumToString(gResp, tempS);
  1266.                 }
  1267.             else {
  1268.                 *(short *)tempS = dash;
  1269.                 }
  1270.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1271.             /* System architecture info */
  1272.             if (Gestalt(gestaltSysArchitecture, &gResp) == noErr) {
  1273.                 MyNumToString(gResp, tempS);
  1274.                 }
  1275.             else {
  1276.                 *(short *)tempS = dash;
  1277.                 }
  1278.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1279.             /* Native processor info */
  1280.             if (Gestalt(gestaltNativeCPUtype, &gResp) == noErr) {
  1281.                 MyNumToString(gResp, tempS);
  1282.                 }
  1283.             else {
  1284.                 *(short *)tempS = dash;
  1285.                 }
  1286.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1287.             /* System 7 tuner info */
  1288.             if (Gestalt('bugz', &gResp) == noErr) {
  1289.                 MyNumToString(gResp, tempS);
  1290.                 }
  1291.             else {
  1292.                 *(short *)tempS = dash;
  1293.                 }
  1294.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1295.             /* Hardware System Updater info */
  1296.             if (Gestalt('bugy', &gResp) == noErr) {
  1297.                 MyNumToString(gResp, tempS);
  1298.                 }
  1299.             else {
  1300.                 *(short *)tempS = dash;
  1301.                 }
  1302.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1303.             /* Hardware System Updater 3 info */
  1304.             if (Gestalt('bugx', &gResp) == noErr) {
  1305.                 MyNumToString(gResp, tempS);
  1306.                 }
  1307.             else {
  1308.                 *(short *)tempS = dash;
  1309.                 }
  1310.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1311.             /* AppleScript info */
  1312.             if (Gestalt(gestaltAppleScriptVersion, &gResp) == noErr) {
  1313.                 BCDLongVersNumToString(gResp, tempS);
  1314.                 }
  1315.             else {
  1316.                 *(short *)tempS = dash;
  1317.                 }
  1318.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1319.             /* QuickTime info */
  1320.             if (Gestalt(gestaltQuickTimeVersion, &gResp) == noErr) {
  1321.                 BCDLongVersNumToString(gResp, tempS);
  1322.                 }
  1323.             else {
  1324.                 *(short *)tempS = dash;
  1325.                 }
  1326.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1327.             /* Thread Manager info */
  1328.             if (Gestalt(gestaltThreadMgrAttr, &gResp) == noErr) {
  1329.                 MyNumToString(gResp, tempS);
  1330.                 }
  1331.             else {
  1332.                 *(short *)tempS = dash;
  1333.                 }
  1334.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1335.             /* Display Manager attr */
  1336.             if (Gestalt(gestaltDisplayMgrAttr, &gResp) == noErr) {
  1337.                 MyNumToString(gResp, tempS);
  1338.                 }
  1339.             else {
  1340.                 *(short *)tempS = dash;
  1341.                 }
  1342.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1343.             /* Display Manager version */
  1344.             if (Gestalt(gestaltDisplayMgrVers, &gResp) == noErr) {
  1345.                 MyNumToString(gResp, tempS);
  1346.                 }
  1347.             else {
  1348.                 *(short *)tempS = dash;
  1349.                 }
  1350.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1351.             /* Drag Manager attr */
  1352.             if (Gestalt(gestaltDragMgrAttr, &gResp) == noErr) {
  1353.                 MyNumToString(gResp, tempS);
  1354.                 }
  1355.             else {
  1356.                 *(short *)tempS = dash;
  1357.                 }
  1358.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1359.             /* AE attr */
  1360.             if (Gestalt(gestaltAppleEventsAttr, &gResp) == noErr) {
  1361.                 MyNumToString(gResp, tempS);
  1362.                 }
  1363.             else {
  1364.                 *(short *)tempS = dash;
  1365.                 }
  1366.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1367.             /* Finder attr */
  1368.             if (Gestalt(gestaltFinderAttr, &gResp) == noErr) {
  1369.                 MyNumToString(gResp, tempS);
  1370.                 }
  1371.             else {
  1372.                 *(short *)tempS = dash;
  1373.                 }
  1374.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1375.             /* FS attr */
  1376.             if (Gestalt(gestaltFSAttr, &gResp) == noErr) {
  1377.                 MyNumToString(gResp, tempS);
  1378.                 }
  1379.             else {
  1380.                 *(short *)tempS = dash;
  1381.                 }
  1382.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1383.             /* OS attr */
  1384.             if (Gestalt(gestaltOSAttr, &gResp) == noErr) {
  1385.                 MyNumToString(gResp, tempS);
  1386.                 }
  1387.             else {
  1388.                 *(short *)tempS = dash;
  1389.                 }
  1390.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1391.             /* Standard File attr */
  1392.             if (Gestalt(gestaltStandardFileAttr, &gResp) == noErr) {
  1393.                 MyNumToString(gResp, tempS);
  1394.                 }
  1395.             else {
  1396.                 *(short *)tempS = dash;
  1397.                 }
  1398.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1399.             /* TextEdit attr */
  1400.             if (Gestalt(gestaltTEAttr, &gResp) == noErr) {
  1401.                 MyNumToString(gResp, tempS);
  1402.                 }
  1403.             else {
  1404.                 *(short *)tempS = dash;
  1405.                 }
  1406.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1407.             /* custom configuration */
  1408.             if (regCfgInfo)
  1409.                 lOffset = regCfgInfo(regText, lOffset, tempS);
  1410.             
  1411.             /* quantity */
  1412.             lOffset = Munger(regText, lOffset, &optspace, 1L, ®Info[kItemQuantity-3][1], regInfo[kItemQuantity-3][0]);
  1413.             StringToNum(regInfo[kItemQuantity-3], &gResp);
  1414.             MyNumToString(howManyDollars * sqrt(gResp), tempS);
  1415.     //        UnloadSeg(sqrt);
  1416.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1417.             IUDateString(LMGetTime(), longDate, tempS);
  1418.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1419. // 6
  1420.             if ((err = FSpCreateCompat(&theChosenFile.destFile, 'ttxt', 'TEXT', theChosenFile.theScript)) == noErr) {
  1421.                 if ((err = FSpOpenDFCompat(&theChosenFile.destFile, fsWrPerm, &tmpFRefN)) == noErr) {
  1422. // 6
  1423.                     HLockHi(regText);
  1424.                     myPB.ioParam.ioCompletion = nil;
  1425.                     myPB.ioParam.ioBuffer = *regText;
  1426.                     myPB.ioParam.ioReqCount = InlineGetHandleSize(regText);
  1427.                     myPB.ioParam.ioPosMode = fsFromStart;
  1428.                     myPB.ioParam.ioRefNum = tmpFRefN;
  1429.                     myPB.ioParam.ioPosOffset = 0L;
  1430.                     (void)PBWriteAsync(&myPB);
  1431.                     while (myPB.ioParam.ioResult > 0) {
  1432.                         SystemTask();
  1433.                         (void)EventAvail(everyEvent, &dummyEv);
  1434.                         }
  1435.                     HUnlock(regText);
  1436.                     (void)FSClose(tmpFRefN);
  1437.                     InitCursor();
  1438.                     MyNumToString(myPB.ioParam.ioResult, tempS);
  1439.                     ParamText(theChosenFile.destFile.name, tempS, nil, nil);
  1440.                     if (myPB.ioParam.ioResult == noErr) {
  1441.                         (void) NoteAlert(kALRT_REGSUCCESSSAVED, nil);
  1442.                         }
  1443.                     else if (myPB.ioParam.ioResult == dskFulErr) {
  1444. // 6
  1445.                         (void) FSpDeleteCompat(&theChosenFile.destFile);
  1446. // 6
  1447.                         (void) StopAlert(kALRT_REGDISKFULL, nil);
  1448.                         }
  1449.                     else
  1450.                         (void) StopAlert(kALRT_REGUNKNOWNWRITEERROR, nil);
  1451.                     }
  1452.                 else
  1453.                     (void) StopAlert(kALRT_REGCOULDNOTOPENFORWRITING, nil);
  1454.                 }
  1455.             else
  1456.                 (void) StopAlert(kALRT_REGCOULDNOTCREATE, nil);
  1457.             DisposeHandle(regText);
  1458.             }
  1459.         }
  1460.     DisposePtr((Ptr)regInfo[0]);
  1461.     }
  1462. else
  1463.     SysBeep(30);
  1464. }
  1465.  
  1466. void RegInitProc(DialogPtr myDPtr)
  1467. {
  1468. Str255    textStr, discountStr;
  1469. Rect    iRect;
  1470. //GrafPtr    savePort;
  1471. Handle    iHandle;
  1472. long    qty;
  1473. short    iType;
  1474. //register RgnHandle    updtRgn;
  1475.  
  1476. GetDialogItem(myDPtr, kItemQuantity, &iType, &iHandle, &iRect);
  1477. GetDialogItemText(iHandle, textStr);
  1478. StringToNum(textStr, &qty);
  1479. MyNumToString(gHowManyDollars * qty, textStr);
  1480. MyNumToString(gHowManyDollars * sqrt(qty), discountStr);
  1481. //UnloadSeg(sqrt);
  1482. ParamText(nil, textStr, discountStr, nil);
  1483. GetDialogItem(myDPtr, kItemTotals, &iType, &iHandle, &iRect);
  1484. // correggere con InvalRect !!!!
  1485. /*updtRgn = NewRgn();
  1486. if (updtRgn) {
  1487.     RectRgn(updtRgn, &iRect);
  1488.     UpdtDialog(myDPtr, updtRgn);
  1489.     DisposeRgn(updtRgn);
  1490.     }
  1491. */
  1492. //GetPort(&savePort);
  1493. //SetPort(myDPtr);
  1494. //DebugStr("\pInvalRect imminent");
  1495. InvalRect(&iRect);
  1496. //SetPort(savePort);
  1497. }
  1498.  
  1499. OSErr AskForDestFile(StdFileResultPtr whichFile, ConstStr255Param prompt, StringPtr docName)
  1500. {
  1501. enum {
  1502. kSTR_PROMPT = 300,
  1503. kSTR_DEFNAME
  1504. };
  1505.  
  1506. StandardFileReply    mySFR;
  1507. register Handle    sH1;
  1508. register Handle    sH2;
  1509. register SignedByte    state1, state2;
  1510. register OSErr    err = userCanceledErr;
  1511.  
  1512. // 6
  1513. FabStandardPutFile(prompt ? prompt : (sH1 = (Handle)GetString(kSTR_PROMPT),
  1514.                                         state1 = WantThisHandleSafe(sH1),
  1515.                                         (ConstStr255Param)*sH1),
  1516.                 docName ? docName : (sH2 = (Handle)GetString(kSTR_DEFNAME),
  1517.                                     state2 = WantThisHandleSafe(sH2),
  1518.                                     (ConstStr255Param)*sH2),
  1519.                 &mySFR);
  1520. // 6
  1521.  
  1522. if (docName == nil)
  1523.     HSetState(sH2, state2);
  1524. if (prompt == nil)
  1525.     HSetState(sH1, state1);
  1526.  
  1527. if (mySFR.sfGood) {
  1528.     if (mySFR.sfReplacing)
  1529.         err = dupFNErr;
  1530.     else {
  1531.         err = noErr;
  1532.         whichFile->destFile = mySFR.sfFile;
  1533.         whichFile->theScript = mySFR.sfScript;
  1534.         if (docName)
  1535.             (void) PLstrncpy(docName, mySFR.sfFile.name, 31);
  1536.         }
  1537.     }
  1538. return err;
  1539. }
  1540.  
  1541. void BCDVersNumToString(long num, StringPtr str)
  1542. {
  1543. Str15    tmpstr;
  1544. const short    onepoint = 0x012E;
  1545. register long    tmp;
  1546.  
  1547. str[0] = 0;
  1548. tmp = num;
  1549. tmp >>= 8;
  1550. tmp &= 0xFF;
  1551. MyNumToString(tmp, str);
  1552. (void) PLstrcat(str, (StringPtr)&onepoint);
  1553. tmp = num;
  1554. tmp >>= 4;
  1555. tmp &= 0xF;
  1556. MyNumToString(tmp, tmpstr);
  1557. (void) PLstrcat(str, (StringPtr)&tmpstr);
  1558. tmp = num;
  1559. tmp &= 0xF;
  1560. if (tmp) {
  1561.     MyNumToString(tmp, tmpstr);
  1562.     (void) PLstrcat(str, (StringPtr)&onepoint);
  1563.     (void) PLstrcat(str, (StringPtr)&tmpstr);
  1564.     }
  1565. }
  1566.  
  1567. void BCDLongVersNumToString(long num, StringPtr str)
  1568. {
  1569. Str15    tmpstr;
  1570. const short    onepoint = 0x012E;
  1571. const short    devStr = 0x0164;
  1572. const short    alphaStr = 0x0161;
  1573. const short    betaStr = 0x0162;
  1574. const short    releaseStr = 0x0172;
  1575. register long    tmp;
  1576.  
  1577. str[0] = 0;
  1578. tmp = num;
  1579. tmp >>= 24;
  1580. tmp &= 0xFF;
  1581. MyNumToString(tmp, str);
  1582. (void) PLstrcat(str, (StringPtr)&onepoint);
  1583. tmp = num;
  1584. tmp >>= 20;
  1585. tmp &= 0xF;
  1586. MyNumToString(tmp, tmpstr);
  1587. (void) PLstrcat(str, (StringPtr)&tmpstr);
  1588. tmp = num;
  1589. tmp >>= 16;
  1590. tmp &= 0xF;
  1591. if (tmp) {
  1592.     MyNumToString(tmp, tmpstr);
  1593.     (void) PLstrcat(str, (StringPtr)&onepoint);
  1594.     (void) PLstrcat(str, (StringPtr)&tmpstr);
  1595.     }
  1596. tmp = num;
  1597. tmp >>= 8;
  1598. tmp &= 0xFF;
  1599. switch (tmp) {
  1600.     case developStage:
  1601.         (void) PLstrcat(str, (StringPtr)&devStr);
  1602.         break;
  1603.     case alphaStage:
  1604.         (void) PLstrcat(str, (StringPtr)&alphaStr);
  1605.         break;
  1606.     case betaStage:
  1607.         (void) PLstrcat(str, (StringPtr)&betaStr);
  1608.         break;
  1609.     case finalStage:
  1610.         (void) PLstrcat(str, (StringPtr)&releaseStr);
  1611.         break;
  1612.     }
  1613. tmp = num;
  1614. tmp &= 0xFF;
  1615. if (tmp) {
  1616.     MyNumToString(tmp, tmpstr);
  1617.     (void) PLstrcat(str, (StringPtr)&tmpstr);
  1618.     }
  1619. }
  1620.  
  1621. #if    !defined(FabNoSegmentDirectives)
  1622. #pragma segment Init
  1623. #endif
  1624.  
  1625. /* Code from Apple® converted by Stefan Kurth in super-optimized (!) C */
  1626.  
  1627. /* InitGraf is always implemented (trap $A86E). If the trap table is big
  1628.   enough, trap $AA6E will always point to either Unimplemented or some other
  1629.   trap, but will never be the same as InitGraf. Thus, you can check the size
  1630.   of the trap table by asking if the address of trap $A86E is the same as
  1631.   $AA6E. */
  1632.  
  1633. #define NumToolboxTraps    ((GetToolTrapAddress(_InitGraf) == GetToolTrapAddress(0xAA6E)) ? 0x0200 : 0x0400)
  1634.  
  1635. /* Determines the type of a trap based on its trap number. If bit 11 is clear,
  1636.   then it is an OS trap. Otherwise, it is a Toolbox trap. */
  1637. /* OS traps start with A0, Tool with A8 or AA. */
  1638.  
  1639. #define GetTrapType(which)    (((which) & 0x0800) ? ToolTrap : OSTrap)
  1640. #define IsToolTrap(trap)    ((trap) & 0x0800)
  1641.  
  1642. /* Check to see if a given trap is implemented. This is only used by the
  1643.   Initialize routine in this program, so we put it in the Initialize segment.*/
  1644.  
  1645. Boolean TrapAvailable(short theTrap)
  1646. {
  1647. register UniversalProcPtr    theTrapAddress;
  1648. register short    temp;
  1649.  
  1650. temp = theTrap;
  1651. if(IsToolTrap(temp)) {
  1652.     temp &= 0x07FF;
  1653.     if( temp >= NumToolboxTraps)
  1654.         return false;
  1655.     theTrapAddress = GetToolTrapAddress(temp);
  1656.     }
  1657. else
  1658.     theTrapAddress = GetOSTrapAddress(temp);
  1659. return( GetToolTrapAddress(_Unimplemented) != theTrapAddress);
  1660. }
  1661.  
  1662. OSErr InstallRequiredAEHandlers(AEEventHandlerProcPtr myOAPP,
  1663.                                 AEEventHandlerProcPtr myODOC,
  1664.                                 AEEventHandlerProcPtr myPDOC,
  1665.                                 AEEventHandlerProcPtr myQUIT)
  1666. {
  1667. OSErr    err;
  1668.  
  1669. gmyOAPP_UPP = NewAEEventHandlerProc(myOAPP);
  1670. gmyODOC_UPP = NewAEEventHandlerProc(myODOC);
  1671. gmyPDOC_UPP = NewAEEventHandlerProc(myPDOC);
  1672. gmyQUIT_UPP = NewAEEventHandlerProc(myQUIT);
  1673. if(noErr == (err = AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, gmyOAPP_UPP, 0, false)))
  1674.     if(noErr == (err = AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, gmyODOC_UPP, 0, false)))
  1675.         if(noErr == (err = AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments, gmyPDOC_UPP, 0, false)))
  1676.             if(noErr == (err = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication, gmyQUIT_UPP, 0, false)))
  1677.                 ;
  1678.  
  1679. return err;
  1680. }
  1681.  
  1682. #endif
  1683.  
  1684.